home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / djgpp / contrib / pdcurs22 / samples / tui.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-26  |  18.6 KB  |  738 lines
  1. /*
  2. ***************************************************************************
  3. * This file comprises part of PDCurses. PDCurses is Public Domain software.
  4. * You may use this code for whatever purposes you desire. This software
  5. * is provided AS IS with NO WARRANTY whatsoever.
  6. * Should this software be used in another application, an acknowledgement
  7. * that PDCurses code is used would be appreciated, but is not mandatory.
  8. *
  9. * Any changes which you make to this software which may improve or enhance
  10. * it, should be forwarded to the current maintainer for the benefit of 
  11. * other users.
  12. *
  13. * The only restriction placed on this code is that no distribution of
  14. * modified PDCurses code be made under the PDCurses name, by anyone
  15. * other than the current maintainer.
  16. * 
  17. * See the file maintain.er for details of the current maintainer.
  18. ***************************************************************************
  19. */
  20. /********************************* tui.c ************************************/
  21. /*
  22.  * File   : tui.c      'textual user interface'
  23.  * Author : P.J. Kunst  (kunst@prl.philips.nl)
  24.  * Date   : 25-02-93
  25.  * Version: 1.02
  26.  */
  27.  
  28. #include <ctype.h>
  29. #include <curses.h>
  30. #include <stdio.h>
  31. #include <stdlib.h>
  32. #include <string.h>
  33. #include <time.h>
  34. #include "tui.h"
  35.  
  36. #ifdef PDCDEBUG
  37. char *rcsid_tui  = "$Id$";
  38. #endif
  39.  
  40. #if defined(__unix) && !defined(GO32)
  41. #define CPUACCOUNT                /* necessary if CPU cycles are to be paid! */
  42. #endif
  43.  
  44. #ifdef A_COLOR
  45. # define TITLECOLOR         1                   /* color pair indices */
  46. # define MAINMENUCOLOR      (2 | A_BOLD)
  47. # define MAINMENUREVCOLOR   (3 | A_BOLD | A_REVERSE)
  48. # define SUBMENUCOLOR       (4 | A_BOLD)
  49. # define SUBMENUREVCOLOR    (5 | A_BOLD | A_REVERSE)
  50. # define BODYCOLOR          6
  51. # define STATUSCOLOR        (7 | A_BOLD)
  52. # define INPUTBOXCOLOR      8
  53. # define EDITBOXCOLOR       (9 | A_BOLD | A_REVERSE)
  54. #else
  55. # define TITLECOLOR         0                   /* color pair indices */
  56. # define MAINMENUCOLOR      (A_BOLD)
  57. # define MAINMENUREVCOLOR   (A_BOLD | A_REVERSE)
  58. # define SUBMENUCOLOR       (A_BOLD)
  59. # define SUBMENUREVCOLOR    (A_BOLD | A_REVERSE)
  60. # define BODYCOLOR          0
  61. # define STATUSCOLOR        (A_BOLD)
  62. # define INPUTBOXCOLOR      0
  63. # define EDITBOXCOLOR       (A_BOLD | A_REVERSE)
  64. #endif
  65.  
  66.  
  67. #define  th   1                   /* title window height */
  68. #define  mh   1                   /* main menu height */
  69. #define  sh   2                   /* status window height */
  70. #define  bh   (LINES-th-mh-sh-1)  /* body window height */
  71. #define  bw   COLS                /* body window width */
  72.  
  73.  
  74. /******************************* STATIC ************************************/
  75.  
  76. static WINDOW *wtitl, *wmain, *wbody, *wstat; /* title, menu, body, status win*/
  77. static int nexty, nextx;
  78. static int key = ERR, ch = ERR;
  79. static bool quit = FALSE;
  80. static bool incurses = FALSE;
  81.  
  82. #ifndef PDCURSES
  83. static char wordchar (void) { return 0x17; }  /* ^W */ 
  84. #endif
  85.  
  86. static char *padstr (char *s, int length)
  87. {
  88.   static char buf[MAXSTRLEN];
  89.   char fmt[10];
  90.  
  91.   sprintf (fmt, strlen(s)>length ? "%%.%ds" : "%%-%ds", length);
  92.   sprintf (buf, fmt, s);
  93.   return buf;
  94. }
  95.  
  96. static char *prepad (char *s, int length)
  97. {
  98.   int i;
  99.   char *p = s;
  100.  
  101.   if (length > 0)
  102.   {
  103.     memmove ((void *)(s+length), (const void *)s, strlen(s)+1);
  104.     for (i=0; i<length; i++) *p++ = ' ';
  105.   }
  106.   return s;
  107. }
  108.  
  109. static void rmline (WINDOW *win, int nr)   /* keeps box lines intact */
  110. {
  111.   mvwaddstr (win, nr, 1, padstr(" ", bw-2));
  112.   wrefresh (win);
  113. }
  114.  
  115. static void initcolor (void)
  116. {
  117. #ifdef A_COLOR
  118.   if (has_colors()) start_color();     /* foreground, background */
  119.   init_pair (TITLECOLOR       & ~A_ATTR, COLOR_BLACK, COLOR_CYAN);      
  120.   init_pair (MAINMENUCOLOR    & ~A_ATTR, COLOR_WHITE, COLOR_CYAN);    
  121.   init_pair (MAINMENUREVCOLOR & ~A_ATTR, COLOR_WHITE, COLOR_BLACK);
  122.   init_pair (SUBMENUCOLOR     & ~A_ATTR, COLOR_WHITE, COLOR_CYAN);    
  123.   init_pair (SUBMENUREVCOLOR  & ~A_ATTR, COLOR_WHITE, COLOR_BLACK);   
  124.   init_pair (BODYCOLOR        & ~A_ATTR, COLOR_WHITE, COLOR_BLUE);      
  125.   init_pair (STATUSCOLOR      & ~A_ATTR, COLOR_WHITE, COLOR_CYAN);   
  126.   init_pair (INPUTBOXCOLOR    & ~A_ATTR, COLOR_BLACK, COLOR_CYAN);
  127.   init_pair (EDITBOXCOLOR     & ~A_ATTR, COLOR_WHITE, COLOR_BLACK);
  128. #endif
  129. }
  130.  
  131. static void setcolor (WINDOW *win, chtype color)
  132. {
  133.   chtype attr = color & A_ATTR;  /* extract Bold, Reverse, Blink bits */
  134.  
  135. #ifdef A_COLOR
  136.   attr &= ~A_REVERSE;  /* ignore reverse, use colors instead! */
  137.   wattrset (win, COLOR_PAIR(color & A_CHARTEXT) | attr);
  138. #else
  139.   attr &= ~A_BOLD;     /* ignore bold, gives messy display on HP-UX */
  140.   wattrset (win, attr);
  141. #endif
  142. }
  143.  
  144. static void colorbox (WINDOW *win, chtype color, int hasbox)
  145. {
  146.   chtype attr = color & A_ATTR;  /* extract Bold, Reverse, Blink bits */
  147.  
  148.   setcolor (win, color);
  149. #ifdef A_COLOR
  150.   if (has_colors())
  151.      wbkgd (win, COLOR_PAIR(color & A_CHARTEXT) | (attr & ~A_REVERSE));
  152.   else
  153.      wbkgd (win, color);
  154. #else
  155.   wbkgd (win, color);
  156. #endif
  157.   werase (win); 
  158.   if (hasbox && win->_maxy > 2) box (win, 0, 0);
  159.   touchwin (win); wrefresh (win);
  160. }
  161.  
  162. static void idle (void)
  163. {
  164.   char buf[MAXSTRLEN];
  165.   time_t t;
  166.   struct tm *tp;
  167.  
  168.   if (time (&t) == -1) return;  /* time not available */
  169.   tp = localtime(&t);
  170.   sprintf (buf, " %.2d-%.2d-%.2d  %.2d:%.2d:%.2d", 
  171.     tp->tm_mday, tp->tm_mon + 1, tp->tm_year,
  172.     tp->tm_hour, tp->tm_min, tp->tm_sec);
  173.   mvwaddstr (wtitl, 0, bw-strlen(buf)-2, buf);
  174.   wrefresh (wtitl); 
  175. #ifdef CPUACCOUNT
  176.   sleep (1);    /* necessary if CPU cycles are to be paid ! */
  177. #endif
  178. }
  179.  
  180. static void menudim (menu *mp, int *lines, int *columns)
  181. {
  182.   int n, l, max = 0;
  183.  
  184.   for (n=0; mp->func; n++, mp++)
  185.     if ((l = strlen(mp->name)) > max) max = l;
  186.   *lines = n;
  187.   *columns = max + 2;
  188. }
  189.  
  190. static void setmenupos (int y, int x)
  191. {
  192.   nexty = y; nextx = x;
  193. }
  194.  
  195. static void getmenupos (int *y, int *x)
  196. {
  197.   *y = nexty; *x = nextx;
  198. }
  199.  
  200. static int hotkey (char *s)
  201. {
  202.   int c, c0 = *s;  /* if no upper case found, return first char */
  203.  
  204.   for (c = *s; c; s++) if (isupper(c)) break;
  205.   return c ? c : c0;
  206. }
  207.  
  208. static void repaintmenu (WINDOW *wmenu, menu *mp)
  209. {
  210.   int i;
  211.   menu *p = mp;
  212.  
  213.   for (i=0; p->func; i++, p++)
  214.     mvwaddstr (wmenu, i+1, 2, p->name);
  215.   touchwin (wmenu); wrefresh (wmenu);
  216. }
  217.  
  218. static void repaintmainmenu (int width, menu *mp)
  219. {
  220.   int i;
  221.   menu *p = mp;
  222.  
  223.   for (i=0; p->func; i++, p++)
  224.     mvwaddstr (wmain, 0, i*width, prepad (padstr(p->name, width-1), 1));
  225.   touchwin (wmain); wrefresh (wmain);
  226. }
  227.  
  228. static void mainhelp (void)
  229. {
  230. #ifdef ALT_X
  231.   statusmsg ("Use arrow keys and Enter to select (Alt-X to quit)");
  232. #else
  233.   statusmsg ("Use arrow keys and Enter to select");
  234. #endif
  235. }
  236.  
  237. static void hidecursor (void)
  238. {
  239. #if defined(PDCURSES) || defined(SYSV)
  240.   curs_set (0);
  241. #endif
  242. }
  243.  
  244. static void normalcursor (void)
  245. {
  246. #if defined(PDCURSES) || defined(SYSV)
  247.   curs_set (1);
  248. #endif
  249. }
  250.  
  251. static void insertcursor (void)
  252. {
  253. #if defined(PDCURSES) || defined(SYSV)
  254.   curs_set (2);
  255. #endif
  256. }
  257.  
  258. static void mainmenu (menu *mp)
  259. {
  260.   int nitems, barlen, old = -1, cur = 0, c, cur0;
  261.  
  262.   menudim (mp, &nitems, &barlen);
  263.   repaintmainmenu (barlen, mp);
  264.  
  265.   while (!quit)
  266.   {
  267.     if (cur != old)
  268.     {
  269.       if (old != -1)
  270.       {
  271.         mvwaddstr (wmain, 0, old*barlen, 
  272.           prepad (padstr(mp[old].name, barlen-1), 1));
  273.         statusmsg (mp[cur].desc);
  274.       }
  275.       else mainhelp ();
  276.       setcolor (wmain, MAINMENUREVCOLOR);
  277.       mvwaddstr (wmain, 0, cur*barlen, 
  278.         prepad (padstr(mp[cur].name, barlen-1), 1));
  279.       setcolor (wmain, MAINMENUCOLOR);
  280.       old = cur;
  281.       wrefresh (wmain);
  282.     }
  283.     switch (c = (key != ERR ? key : waitforkey()))
  284.     {
  285.       case KEY_DOWN:
  286.       case '\n':                              /* menu item selected ! */
  287.         touchwin (wbody); wrefresh (wbody);
  288.         rmerror ();
  289.         setmenupos (th+mh, cur*barlen);
  290.         normalcursor ();
  291.         (mp[cur].func)();                     /* perform function */
  292.         hidecursor ();
  293.         switch (key)
  294.         {
  295.           case KEY_LEFT:
  296.             cur = (cur+nitems-1) % nitems;
  297.             key = '\n';
  298.             break;
  299.  
  300.           case KEY_RIGHT:
  301.             cur = (cur+1) % nitems;
  302.             key = '\n';
  303.             break;
  304.  
  305.           default:
  306.             key = ERR;
  307.             break;
  308.         }
  309.         repaintmainmenu (barlen, mp);
  310.         old = -1;
  311.         break;
  312.  
  313.       case KEY_LEFT:
  314.         cur = (cur+nitems-1) % nitems;
  315.         break;
  316.  
  317.       case KEY_RIGHT:
  318.         cur = (cur+1) % nitems;
  319.         break;
  320.  
  321.       case KEY_ESC:
  322.         mainhelp ();
  323.         break;
  324.  
  325.       default:
  326.         cur0 = cur;
  327.         do { cur = (cur+1) % nitems;
  328.         } while ((cur != cur0) && (hotkey(mp[cur].name) != toupper(c)));
  329.         if (hotkey(mp[cur].name) == toupper(c)) key = '\n';
  330.         break;
  331.     }
  332.   }
  333.   rmerror ();
  334.   touchwin (wbody); wrefresh (wbody);
  335. }
  336.  
  337. static void cleanup (void) /* cleanup curses settings */
  338. {
  339.   if (incurses)
  340.   {
  341.     delwin (wtitl);
  342.     delwin (wmain);
  343.     delwin (wbody);
  344.     delwin (wstat);
  345.     normalcursor ();
  346.     endwin (); 
  347.     incurses = FALSE;
  348.   }
  349. }
  350.  
  351.  
  352. /******************************* EXTERNAL **********************************/
  353.  
  354. void clsbody (void)
  355. {
  356.   werase (wbody); wmove (wbody, 0, 0);
  357. }
  358.  
  359. int bodylen (void)
  360. {
  361.   return wbody->_maxy;
  362. }
  363.  
  364. WINDOW *bodywin (void)
  365. {
  366.   return wbody;
  367. }
  368.  
  369. void rmerror (void)
  370. {
  371.   rmline (wstat, 0);
  372. }
  373.  
  374. void rmstatus (void)
  375. {
  376.   rmline (wstat, 1);
  377. }
  378.  
  379. void titlemsg (char *msg)
  380. {
  381.   mvwaddstr (wtitl, 0, 2, padstr(msg, bw-3));
  382.   wrefresh (wtitl);
  383. }
  384.  
  385. void bodymsg (char *msg)
  386. {
  387.   waddstr (wbody, msg);
  388.   wrefresh (wbody);
  389. }
  390.  
  391. void errormsg (char *msg)
  392. {
  393.   beep ();
  394.   mvwaddstr (wstat, 0, 2, padstr(msg, bw-3));
  395.   wrefresh (wstat);
  396. }
  397.  
  398. void statusmsg (char *msg)
  399. {
  400.   mvwaddstr (wstat, 1, 2, padstr(msg, bw-3));
  401.   wrefresh (wstat);
  402. }
  403.  
  404. bool keypressed (void)
  405. {
  406.   if (ch == ERR) ch = wgetch(wbody);
  407.   return ch != ERR;
  408. }
  409.  
  410. int getkey (void)
  411. {
  412.   int c = ch;
  413.  
  414.   ch = ERR;
  415. #ifdef ALT_X
  416.   quit = (c == ALT_X);     /* PC only ! */
  417. #endif
  418.   return c;
  419. }
  420.  
  421. void flushkeys (void)
  422. {
  423.   while (keypressed()) getkey();
  424. }
  425.  
  426. int waitforkey (void)
  427. {
  428.   flushkeys ();
  429.   while (!keypressed()) idle ();
  430.   return getkey ();
  431. }
  432.  
  433. void DoExit (void)   /* terminate program */
  434. {
  435.   quit = TRUE;
  436. }
  437.  
  438. void domenu (menu *mp)
  439. {
  440.   int y, x, nitems, barlen, mheight, mw, old = -1, cur = 0, cur0;
  441.   bool stop = FALSE;
  442.   WINDOW *wmenu;
  443.  
  444.   hidecursor ();
  445.   getmenupos (&y, &x);
  446.   menudim (mp, &nitems, &barlen);
  447.   mheight = nitems+2; mw = barlen+2;
  448.   wmenu = newwin (mheight, mw, y, x);
  449.   colorbox (wmenu, SUBMENUCOLOR, 1);
  450.   repaintmenu (wmenu, mp);
  451.  
  452.   key = ERR;
  453.   while (!stop && !quit)
  454.   {
  455.     if (cur != old)
  456.     {
  457.       if (old != -1)
  458.         mvwaddstr (wmenu, old+1, 1, prepad (padstr(mp[old].name, barlen-1), 1));
  459.       setcolor (wmenu, SUBMENUREVCOLOR);
  460.       mvwaddstr (wmenu, cur+1, 1, prepad (padstr(mp[cur].name, barlen-1), 1));
  461.       setcolor (wmenu, SUBMENUCOLOR);
  462.       statusmsg (mp[cur].desc);
  463.       old = cur;
  464.       wrefresh (wmenu);
  465.     }
  466.     switch (key = ((key != ERR) ? key : waitforkey()))
  467.     {
  468.       case '\n':                              /* menu item selected ! */
  469.         touchwin (wbody); wrefresh (wbody);
  470.         setmenupos (y+1, x+1);
  471.         rmerror ();
  472.         key = ERR;
  473.         normalcursor ();
  474.         (mp[cur].func)();                     /* perform function */
  475.         hidecursor ();
  476.         repaintmenu (wmenu, mp);
  477.         old = -1;
  478.         break;
  479.  
  480.       case KEY_UP:
  481.         cur = (cur+nitems-1) % nitems;
  482.         key = ERR;
  483.         break;
  484.  
  485.       case KEY_DOWN:
  486.         cur = (cur+1) % nitems;
  487.         key = ERR;
  488.         break;
  489.  
  490.       case KEY_ESC:
  491.       case KEY_LEFT:
  492.       case KEY_RIGHT:
  493.         if (key == KEY_ESC) key = ERR;  /* return to previous submenu */
  494.         stop = TRUE;
  495.         break;
  496.  
  497.       default:
  498.         cur0 = cur;
  499.         do { cur = (cur+1) % nitems;
  500.         } while ((cur != cur0) && (hotkey(mp[cur].name) != toupper((int)key)));
  501.         key = (hotkey(mp[cur].name) == toupper((int)key)) ? '\n' : ERR;
  502.         break;
  503.     }
  504.   }
  505.   rmerror ();
  506.   delwin (wmenu);
  507.   touchwin (wbody); wrefresh (wbody);
  508. }
  509.  
  510. void startmenu (menu *mp, char *title)
  511. {
  512.   initscr ();
  513.   incurses = TRUE;
  514.   initcolor ();
  515. /*  atexit (cleanup); */
  516.  
  517.   wtitl = subwin (stdscr, th,  bw,    0, 0);
  518.   wmain = subwin (stdscr, mh,  bw,   th, 0);
  519.   wbody = subwin (stdscr, bh,  bw,  th+mh, 0);
  520.   wstat = subwin (stdscr, sh,  bw, th+mh+bh, 0);
  521.  
  522.   colorbox (wtitl, TITLECOLOR, 0);
  523.   colorbox (wmain, MAINMENUCOLOR, 0);
  524.   colorbox (wbody, BODYCOLOR, 0);
  525.   colorbox (wstat, STATUSCOLOR, 0);
  526.  
  527.   if (title) titlemsg (title);
  528.  
  529.   cbreak ();                /* direct input (no newline required)... */
  530.   noecho ();                /* ... without echoing */
  531.   hidecursor ();            /* hide cursor (if possible) */
  532.   nodelay (wbody, TRUE);    /* don't wait for input */
  533.   keypad (wbody, TRUE);     /* enable cursor keys */
  534.   scrollok (wbody, TRUE);   /* enable scrolling in main window */
  535.   leaveok (stdscr, TRUE);
  536.   leaveok (wtitl, TRUE);
  537.   leaveok (wmain, TRUE);
  538.   leaveok (wstat, TRUE);
  539.  
  540.   mainmenu (mp);
  541.  
  542.   cleanup ();
  543. }
  544.  
  545.  
  546. /*man-start*********************************************************************
  547.  
  548.   weditstr()     - edit string
  549.  
  550.   PDCurses Description:
  551.         The initial value of 'str' with a maximum length of 'field'-1,
  552.         which is supplied by the calling routine, is editted. The user's 
  553.         erase (^H), kill (^U) and delete word (^W) chars are interpreted. 
  554.         The PC insert or Tab keys toggle between insert and edit mode.
  555.         Escape aborts the edit session, leaving 'str' unchanged.
  556.         Enter, Up or Down Arrow are used to accept the changes to 'str'.
  557.  
  558.         NOTE: editstr(), mveditstr(), and mvweditstr() are macros.
  559.  
  560.   PDCurses Return Value:
  561.         These functions return the input terminating character on 
  562.         success (Escape, Enter, Up or Down Arrow) and ERR on error.
  563.  
  564.   PDCurses Errors:
  565.         It is an error to call this function with a NULL window pointer.
  566.         The length of the initial 'str' must not exceed 'field'-1.
  567.  
  568.   Portability:
  569.         PDCurses        int weditstr( WINDOW* win, char* str, int field );
  570.         X/Open Dec '88 
  571.         BSD Curses    
  572.         SYS V Curses 
  573.  
  574. **man-end**********************************************************************/
  575.  
  576.  
  577. static void repainteditbox (WINDOW *win, int x, char *buf)
  578. {
  579.   werase (win); mvwprintw (win, 0, 0, "%s", padstr (buf, win->_maxx));
  580.   wmove (win, 0, x); wrefresh (win); 
  581. }
  582.  
  583. int weditstr (WINDOW *win, char *buf, int field)
  584. {
  585.   char org[MAXSTRLEN], *tp, *bp = buf;
  586.   bool defdisp = TRUE, stop = FALSE, insert = FALSE;
  587.   int cury, curx, begy, begx, oldattr;
  588.   WINDOW *wedit;
  589.   int c=0;
  590.  
  591.   if ((field>=MAXSTRLEN) || (buf==NULL) || (strlen(buf) > field-1)) return ERR;
  592.   strcpy (org, buf);  /* save original */
  593.  
  594.   wrefresh (win);
  595.   getyx (win, cury, curx); getbegyx (win, begy, begx);
  596.   wedit = subwin (win, 1, field, begy+cury, begx+curx);  /* window relative */
  597.   oldattr = wedit->_attrs;
  598.   colorbox (wedit, EDITBOXCOLOR, 0);
  599.  
  600.   normalcursor ();
  601. #ifdef CPUACCOUNT
  602.   nodelay (win, FALSE);
  603.   keypad (wedit, TRUE);
  604. #endif
  605.   while (!stop)
  606.   {
  607.     repainteditbox (wedit, bp-buf, buf);
  608. #ifdef CPUACCOUNT
  609.     switch (c = wgetch(wedit))
  610. #else
  611.     switch (c = waitforkey())
  612. #endif
  613.     {
  614.       case KEY_ESC:
  615.         strcpy (buf, org);  /* restore original */
  616.         stop = TRUE;
  617.         break;
  618.  
  619.       case '\n':  /* ENTER */
  620.       case KEY_UP:
  621.       case KEY_DOWN:
  622.         stop = TRUE;
  623.         break;
  624.  
  625.       case KEY_LEFT:
  626.         if (bp > buf) bp--;
  627.         break;
  628.  
  629.       case KEY_RIGHT:
  630.         defdisp = FALSE;
  631.         if (bp - buf < strlen(buf)) bp++;
  632.         break;
  633.  
  634.       case '\t':     /* TAB, because Insert not properly handled on HP-UX ! */
  635.       case KEY_IC:   /* enter insert mode */
  636.       case KEY_EIC:  /* exit insert mode */
  637.         defdisp = FALSE;
  638.         insert = !insert;
  639.         if (insert) insertcursor (); else normalcursor ();
  640.         break;
  641.  
  642.       default:
  643.         if (c == erasechar())  /* backspace, ^H */
  644.         {
  645.           if (bp > buf)
  646.           {
  647.             memmove ((void *)(bp-1), (const void *)bp, strlen(bp)+1);
  648.             bp--;
  649.           }
  650.         }
  651.         else if (c == killchar())  /* ^U */
  652.         {
  653.           bp = buf; *bp = '\0';
  654.         }
  655.         else if (c == wordchar())  /* ^W */
  656.         {
  657.           tp = bp;
  658.           while ((bp > buf) && (*(bp-1) == ' ')) bp--;
  659.           while ((bp > buf) && (*(bp-1) != ' ')) bp--;
  660.           memmove ((void *)bp, (const void *)tp, strlen(tp)+1);
  661.         }
  662.         else if (isprint(c))
  663.         {
  664.           if (defdisp) { bp = buf; *bp = '\0'; defdisp = FALSE; }
  665.           if (insert)
  666.           {
  667.             if (strlen(buf) < field-1)
  668.             {
  669.               memmove ((void *)(bp+1), (const void *)bp, strlen(bp)+1);
  670.               *bp++ = c;
  671.             }
  672.           }
  673.           else if (bp-buf < field-1)
  674.           {
  675.             if (!*bp) bp[1] = '\0'  /* append new string terminator */;
  676.             *bp++ = c;
  677.           }
  678.         }
  679.         break;
  680.     }
  681.   }
  682. #ifdef CPUACCOUNT
  683.   nodelay (win, TRUE);
  684. #endif
  685.   wattrset (wedit, oldattr);
  686.   repainteditbox (wedit, bp-buf, buf);
  687.   delwin (wedit);
  688.   return c;
  689. }
  690.  
  691. WINDOW *winputbox (WINDOW *win, int nlines, int ncols)
  692. {
  693.   int cury, curx, begy, begx;
  694.   WINDOW *winp;
  695.  
  696.   getyx (win, cury, curx); getbegyx (win, begy, begx);
  697.   winp = newwin (nlines, ncols, begy+cury, begx+curx); /* window relative */
  698.   colorbox (winp, INPUTBOXCOLOR, 1);
  699.   return winp;
  700. }
  701.  
  702. int getstrings (char *desc[], char *buf[], int field)
  703. {
  704.   WINDOW *winput;
  705.   int oldy, oldx, maxy, maxx, nlines, ncols, i, n, l, max = 0;
  706.   int c=0;
  707.   bool stop = FALSE;
  708.  
  709.   for (n=0; desc[n]; n++) if ((l = strlen(desc[n])) > max) max = l;
  710.   nlines = n + 2; ncols = max + field + 4;
  711.   getyx (wbody, oldy, oldx); getmaxyx (wbody, maxy, maxx);
  712.   winput = mvwinputbox (wbody, (maxy-nlines)/2, (maxx-ncols)/2, nlines, ncols);
  713.   for (i=0; i<n; i++) mvwprintw (winput, i+1, 2, "%s", desc[i]);
  714.   i = 0;
  715.   while (!stop)
  716.   {
  717.     switch (c = mvweditstr(winput, i+1, max+3, buf[i], field))
  718.     {
  719.       case KEY_ESC:
  720.         stop = TRUE;
  721.         break;
  722.  
  723.       case KEY_UP:
  724.         i = (i+n-1)%n;
  725.         break;
  726.  
  727.       case '\n':
  728.       case '\t':
  729.       case KEY_DOWN:
  730.         if (++i == n) stop = TRUE;  /* all passed ? */
  731.         break;
  732.     }
  733.   }
  734.   delwin (winput);
  735.   touchwin (wbody); wmove (wbody, oldy, oldx); wrefresh (wbody);
  736.   return c;
  737. }
  738.